package org.example.bean;

import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @ClassName LazyNodePool
 * @Description Node对象池
 * @Author hongjun
 * @Date 2024/5/19 下午6:49
 * @Version 1.0
 */
public class NodePool {
    // 使用线程安全的队列存储可用的节点
    private final Queue<Node> availableNodes = new ConcurrentLinkedQueue<>();
    // 池的最大容量
    private final int maxPoolSize;
    // 当前池中总节点数（用于监控）
    private final AtomicInteger currentSize = new AtomicInteger(0);


    /**
     * 构造函数，初始化节点池
     *
     * @param initialSize
     * @param maxPoolSize
     */
    public NodePool(int initialSize, int maxPoolSize) {
        this.maxPoolSize = maxPoolSize;
        for (int i = 0; i < initialSize; i++) {
            Node node = new Node();
            availableNodes.add(node);
            currentSize.incrementAndGet();
        }
    }

    /**
     * 从池中获取一个节点
     *
     * @return
     */
    public Node acquire() {
        Node node = availableNodes.poll();
        if (node != null) {
            node.setInPool(false);
            return node;
        }
        if (currentSize.get() < maxPoolSize) {
            node = new Node();
            currentSize.incrementAndGet();
            return node;
        }
        return new Node(); // 如果超过最大容量，则直接创建新节点
    }

    /**
     * 释放一个节点回池中
     *
     * @param node
     */
    public boolean release(Node node) {
        if (node == null) {
            throw new IllegalArgumentException("Cannot release null node.");
        }
        if (node.isInPool()) {
            return false;
        }
        node.reset();
        node.setInPool(true);
        availableNodes.add(node);
        return true;
    }

    /**
     * 获取当前池中空闲节点数量
     */
    public int getAvailableCount() {
        return availableNodes.size();
    }

}
